package com.jt.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.jt.mapper.ItemCatMapper;
import com.jt.pojo.ItemCat;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;

@Service
public class ItemCatServiceImpl implements ItemCatService {

    @Autowired
    private ItemCatMapper itemCatMapper;

    /*
    * 3层商品分类嵌套，1.一级分类（children(2级商品分类)）
    *               2.二级分类(children(3级商品分类))
    * 一级查询条件：parent_id=0
    * 二级查询条件：parent_id=一级ID
    * 三级查询条件：parent_id=二级ID
    *
    * */
    /*@Override
    public List<ItemCat> findItemCatList(Integer type) {
        long startTime = System.currentTimeMillis();
        //1.查询一级商品分类信息
        QueryWrapper<ItemCat> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("parent_id",0);
        List<ItemCat> oneList = itemCatMapper.selectList(queryWrapper);

        //2.查询二级商品分类信息
        for (ItemCat oneItemCat : oneList){
            queryWrapper.clear();
            queryWrapper.eq("parent_id", oneItemCat.getId());
            List<ItemCat> twoList = itemCatMapper.selectList(queryWrapper);
            //2.查询三级商品分类信息
            for (ItemCat twoItemCat : twoList){
                queryWrapper.clear();
                queryWrapper.eq("parent_id", twoItemCat.getId());
                List<ItemCat> threeList = itemCatMapper.selectList(queryWrapper);
                //将三级商品的信息封装到二级商品的children中
                twoItemCat.setChildren(threeList);

            }
            //将二级商品的信息封装到一级商品的children中
            oneItemCat.setChildren(twoList);

        }
        long endtTime = System.currentTimeMillis();
        System.out.println(endtTime-startTime);
        return oneList;
    }*/

    /*1.准备一个Map集合，实现数据封装
    * Map<key,value>   Map<parent_id,List<ItemCat>>
    * 2.封装的业务说明
    *       Map中的key，parentId如果不存在，可以存储该key
    *               设定key，同时封装一个List集合，将自己作为第一个元素封装到其中
    *               如果存在：根据key获取所有的子集集合，将自己追加进去，形成第二个元素，
    *
    *
    * */

    public Map<Integer,List<ItemCat>> itemCatMap(){
        //1.定义Map集合
        Map<Integer,List<ItemCat>> map = new HashMap<>();
        //2.查询所有的数据库信息(1,2,3级商品信息)
        List<ItemCat> list = itemCatMapper.selectList(null);
        for (ItemCat itemCat : list){
            int parentId = itemCat.getParentId();//获取父级ID

            if (map.containsKey(parentId)){//判断集合中是否已经有parentId
                List<ItemCat> exeList = map.get(parentId);//引用对象
                exeList.add(itemCat);
            }else {
                //没有key，将自己作为第一个list元素
                List<ItemCat> firstList = new ArrayList<>();
                firstList.add(itemCat);
                map.put(parentId, firstList);
            }
        }
        return map;
    }
    @Override
    public List<ItemCat> findItemCatList(Integer level){
        long startTime = System.currentTimeMillis();
        Map<Integer,List<ItemCat>> map = itemCatMap();
        //1.如果level=1，说明获取一级商品分类信息
        if (level == 1){
            return map.get(0);
        }
        if (level == 2){//2.获取一级和二级菜单信息
           return getTwoList(map);
        }

        //3.获取三级菜单信息
        //3.1获取二级商品分类信息     BUG:有的数据可能没有子级 如何处理
        List<ItemCat> oneList = getTwoList(map);
        for (ItemCat oneItemCat : oneList){
            //从一级集合中,获取二级菜单列表
            List<ItemCat> twoList = oneItemCat.getChildren();
            //bug解决: 如果该元素没有2级列表,则跳过本次循环,执行下一次操作
            if(twoList == null || twoList.size()==0){
                continue;
            }

            for (ItemCat twoItemCat : twoList){
                //查询三级商品分类  条件:parentId=2级ID
                List<ItemCat> threeList = map.get(twoItemCat.getId());
                twoItemCat.setChildren(threeList);
            }
        }
        long endTime = System.currentTimeMillis();
        System.out.println(endTime - startTime);
        return oneList;

    }
    public List<ItemCat> getTwoList(Map<Integer,List<ItemCat>> map){
        List<ItemCat> oneList = map.get(0);
        for (ItemCat OneItemCat : oneList){//查询二级，parentId=1级Id
            List<ItemCat> twoList = map.get(OneItemCat.getId());
            OneItemCat.setChildren(twoList);
        }
        return oneList;
    }




    //修改商品状态
    @Override
    @Transactional
    public void updateStatus(ItemCat itemCat) {

        itemCatMapper.updateById(itemCat);
    }
    //增加商品分类
    @Override
    @Transactional
    public void addItemCat(ItemCat itemCat) {
        //状态默认为true
        itemCat.setStatus(true);
        itemCatMapper.insert(itemCat);

    }
    //修改商品信息
    @Override
    @Transactional
    public void updateItemCat(ItemCat itemCat) {

        itemCatMapper.updateById(itemCat);
    }
    //删除商品信息
    @Override
    @Transactional
    public void deleteItemCat(ItemCat itemCat) {
        //3级目录
        if (itemCat.getLevel() == 3){
            itemCatMapper.deleteById(itemCat.getId());
            return;
        }
        if(itemCat.getLevel() == 2){//2级目录
            QueryWrapper queryWrapper = new QueryWrapper();
            queryWrapper.eq("parent_id", itemCat.getId());
            itemCatMapper.delete(queryWrapper);
            itemCatMapper.deleteById(itemCat.getId());
            return;
        }
        if(itemCat.getLevel() == 1){//1级目录
            QueryWrapper queryWrapper = new QueryWrapper();
            queryWrapper.eq("parent_id", itemCat.getId());
            List<ItemCat> twoList = itemCatMapper.selectList(queryWrapper);
            for (ItemCat itemCat1: twoList){
                 QueryWrapper queryWrapper1 = new QueryWrapper();
                 queryWrapper1.eq("parent_id", itemCat1.getId());
                 itemCatMapper.delete(queryWrapper1);
            }
            itemCatMapper.delete(queryWrapper);
            itemCatMapper.deleteById(itemCat.getId());
        }
    }









}
